@abraca/dabra 1.8.1 → 1.9.1

package/dist/abracadabra-provider.cjs

@@ -2468,12 +2468,13 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		try {
 			const parsed = JSON.parse(payload);
 			if (parsed?.type === "error" && parsed.source && parsed.code) {
-				const { source, code, message } = parsed;
-				console.warn(`[Abracadabra] Server error: ${source} (${code}) — ${message}`);
+				const { source, code, message, meta } = parsed;
+				console.warn(`[Abracadabra] Server error: ${source} (${code}) — ${message}`, meta ?? "");
 				this.emit("serverError", {
 					source,
 					code,
-					message: message ?? ""
+					message: message ?? "",
+					meta
 				});
 				return;
 			}
@@ -10455,6 +10456,15 @@ var FileBlobStore = class FileBlobStore extends EventEmitter {
 			this.objectUrls.delete(key);
 		}
 	}
+	/**
+	* Clear the 404 negative-cache entry for (docId, uploadId) so the next
+	* getBlobUrl() re-fetches from the server instead of short-circuiting.
+	* Use on explicit user retry or after reconnect, when the file may have
+	* become available since the last 404.
+	*/
+	clearNotFound(docId, uploadId) {
+		this._notFound.delete(this.blobKey(docId, uploadId));
+	}
 	/** Revoke the object URL and remove the blob from cache. */
 	async evictBlob(docId, uploadId) {
 		const key = this.blobKey(docId, uploadId);
@@ -10855,6 +10865,19 @@ var E2EOfflineStore = class extends OfflineStore {
 *   are fetched on subsequent connects.
 * - After sync, a fresh encrypted snapshot is saved.
 *
+* Client-side compaction:
+* - After `compactionThreshold` encrypted updates have been applied in this
+*   session (local + remote), and the doc has been quiescent for
+*   `compactionQuiescenceMs`, the provider merges the whole Y.Doc, encrypts it,
+*   and sends `snapshot:compact` — the server atomically replaces the per-doc
+*   update log with that single compacted blob. The server acknowledges by
+*   broadcasting `snapshot:compacted`, which emits the `"compacted"` event.
+* - Requires Owner or above (server silently drops non-Owner requests).
+* - Callers that want a final compaction before teardown should
+*   `await provider.compactNow()` before `destroy()`. `destroy()` does not
+*   compact (it'd race with the socket teardown) — any pending debounce is
+*   cancelled.
+*
 * Key availability limitation: if the user's WebAuthn key is not in
 * DocKeyManager's in-memory cache and there is no network, E2E docs show
 * empty — the key fetch requires either a cached in-memory key or network.
@@ -10862,6 +10885,11 @@ var E2EOfflineStore = class extends OfflineStore {
 function fromBase64(b64) {
 	return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
 }
+function toBase64(bytes) {
+	let bin = "";
+	for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(bin);
+}
 var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraProvider {
 	constructor(configuration) {
 		super({
@@ -10871,9 +10899,17 @@ var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraPro
 		this.docKey = null;
 		this.lastSeq = -1;
 		this.e2eStore = null;
+		this.updatesSinceCompaction = 0;
+		this.compactionInFlight = false;
+		this.compactionInFlightTimeout = null;
+		this.compactionDebounceTimer = null;
+		this.destroyed = false;
 		this.docKeyManager = configuration.docKeyManager;
 		this.keystore = configuration.keystore;
 		this.e2eClient = configuration.client;
+		this.compactionEnabled = configuration.compactionEnabled !== false;
+		this.compactionThreshold = Math.max(1, configuration.compactionThreshold ?? 50);
+		this.compactionQuiescenceMs = Math.max(0, configuration.compactionQuiescenceMs ?? 2e3);
 		this.e2eServerOrigin = E2EAbracadabraProvider.deriveServerOrigin(configuration, configuration.client);
 	}
 	/** Fetch the doc key from the server (requires WebAuthn if not cached). */
@@ -10885,6 +10921,10 @@ var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraPro
 	}
 	/** Handle stateless messages including e2e_ready and e2e_update. */
 	receiveStateless(payload) {
+		if (payload.startsWith("snapshot:compacted ")) {
+			this._handleCompactedBroadcast(payload.slice(19));
+			return;
+		}
 		let parsed;
 		try {
 			parsed = JSON.parse(payload);
@@ -10936,6 +10976,7 @@ var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraPro
 			const plaintext = await decryptField(encryptedData, key);
 			yjs.applyUpdate(this.document, plaintext, this);
 			this.lastSeq = Math.max(this.lastSeq, seq);
+			this._noteUpdateApplied();
 		} catch (e) {
 			console.error("[E2EAbracadabraProvider] decryption failed for seq", seq, e);
 		}
@@ -10958,8 +10999,93 @@ var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraPro
 			update: encrypted,
 			documentName: this.configuration.name
 		});
+		this._noteUpdateApplied();
+	}
+	/**
+	* Force an immediate compaction attempt, bypassing the threshold and
+	* quiescence debounce. Resolves once the `snapshot:compact` frame has been
+	* sent (or rejected locally for missing prerequisites — destroyed, no
+	* doc key, or already in-flight). The server acknowledges via a
+	* `snapshot:compacted` broadcast, which emits the `"compacted"` event.
+	*/
+	async compactNow() {
+		if (this.compactionDebounceTimer) {
+			clearTimeout(this.compactionDebounceTimer);
+			this.compactionDebounceTimer = null;
+		}
+		await this._performCompaction();
+	}
+	_noteUpdateApplied() {
+		if (!this.compactionEnabled || this.destroyed) return;
+		this.updatesSinceCompaction += 1;
+		if (this.updatesSinceCompaction < this.compactionThreshold) return;
+		if (this.compactionDebounceTimer) clearTimeout(this.compactionDebounceTimer);
+		this.compactionDebounceTimer = setTimeout(() => {
+			this.compactionDebounceTimer = null;
+			this._performCompaction().catch((e) => {
+				console.error("[E2EAbracadabraProvider] compaction failed:", e);
+			});
+		}, this.compactionQuiescenceMs);
+	}
+	async _performCompaction() {
+		if (this.destroyed) return;
+		if (this.compactionInFlight) return;
+		if (this.updatesSinceCompaction === 0) return;
+		if (!this.synced) return;
+		const key = await this.ensureDocKey();
+		if (!key) return;
+		if (this.destroyed) return;
+		this.compactionInFlight = true;
+		try {
+			const stateVector = yjs.encodeStateVector(this.document);
+			const encrypted = await encryptField(yjs.encodeStateAsUpdate(this.document), key);
+			if (this.destroyed) {
+				this.compactionInFlight = false;
+				return;
+			}
+			const payload = `snapshot:compact ${JSON.stringify({
+				state_vector: toBase64(stateVector),
+				compacted: toBase64(encrypted)
+			})}`;
+			this.sendStateless(payload);
+			this.compactionInFlightTimeout = setTimeout(() => {
+				this.compactionInFlight = false;
+				this.compactionInFlightTimeout = null;
+			}, 3e4);
+		} catch (e) {
+			this.compactionInFlight = false;
+			throw e;
+		}
+	}
+	_handleCompactedBroadcast(jsonStr) {
+		let parsed = {};
+		try {
+			parsed = JSON.parse(jsonStr);
+		} catch {}
+		if (parsed.doc_id && parsed.doc_id !== this.configuration.name) return;
+		if (this.compactionInFlightTimeout) {
+			clearTimeout(this.compactionInFlightTimeout);
+			this.compactionInFlightTimeout = null;
+		}
+		this.compactionInFlight = false;
+		this.updatesSinceCompaction = 0;
+		const event = {
+			docId: parsed.doc_id ?? this.configuration.name,
+			by: parsed.by
+		};
+		this.emit("compacted", event);
 	}
 	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		if (this.compactionDebounceTimer) {
+			clearTimeout(this.compactionDebounceTimer);
+			this.compactionDebounceTimer = null;
+		}
+		if (this.compactionInFlightTimeout) {
+			clearTimeout(this.compactionInFlightTimeout);
+			this.compactionInFlightTimeout = null;
+		}
 		this.e2eStore?.destroy();
 		this.e2eStore = null;
 		super.destroy();